/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package dialogs;

import util.CategoriaNode;
import java.util.Iterator;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.MutableTreeNode;
import javax.swing.tree.TreeNode;
import persistencia.controller.jpa.CategoriaJpaController;
import persistencia.controller.jpa.JdbcController;
import persistencia.controller.jpa.RegistroJpaController;
import persistencia.controller.jpa.exceptions.NonexistentEntityException;
import persistencia.entidade.Categoria;
import persistencia.entidade.Registro;

/**
 *
 * @author Novo usuário
 */
public class MobCatTreeModel extends DefaultTreeModel {

    public static String NODE_REGISTRO_SEM_CAT = "Registros sem categorias";
    public static String NODE_CATEGORIA = "Categorias";
    private CategoriaJpaController catController = new CategoriaJpaController();

    public MobCatTreeModel() {
        super(new DefaultMutableTreeNode("Portal " + JdbcController.getInstance().getSchemanameFormatado()));
        DefaultMutableTreeNode root = (DefaultMutableTreeNode) getRoot();
        DefaultMutableTreeNode aplicacao = new DefaultMutableTreeNode("Aparencia");
        aplicacao.add(new DefaultMutableTreeNode("Tela inicial"));
        aplicacao.add(new DefaultMutableTreeNode("Tela categoria raiz"));
        aplicacao.add(new DefaultMutableTreeNode("Tela categoria"));
        // root.add(aplicacao);

        DefaultMutableTreeNode cats = new DefaultMutableTreeNode(NODE_CATEGORIA);
        try {
            List<Categoria> catsRaiz = catController.findCategoriaRaizEntities();
            for (Iterator<Categoria> it = catsRaiz.iterator(); it.hasNext();) {
                Categoria categoria = it.next();
                CategoriaNode raiz = new CategoriaNode(categoria);
                loadSubCat(raiz);
                cats.add(raiz);
            }
        } catch (Exception ex) {
            return;
        }

        root.add(cats);

        RegistroJpaController regJpa = new RegistroJpaController();
        List<Registro> regs = regJpa.findRegistroEntitiesSemCategoria();
        DefaultMutableTreeNode regsNode = new DefaultMutableTreeNode("Registros sem categorias (" + regs.size() + ")");
        root.add(regsNode);
    }

    public void criarCategoria(String nome, String desc, DefaultMutableTreeNode pai) {
        try {
            Categoria cat = new Categoria();
            cat.setNome(nome);
            cat.setResumoFilhos(desc);
            CategoriaNode categoriaNode = new CategoriaNode(cat);
            if (pai instanceof CategoriaNode) {
                CategoriaNode catPai = (CategoriaNode) pai;
                cat.setCategoriaPai(catPai.getCategoria());
                catPai.add(categoriaNode);
            }
            catController.create(cat);
            categoriaNode.setAllowsChildren(true);
            super.insertNodeInto(categoriaNode, pai, 0);

        } catch (Exception ex) {
            Logger.getLogger(MobCatTreeModel.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    public void editarCategoria(CategoriaNode cat) {
        try {
            super.nodeChanged(cat);
            catController.edit(cat.getCategoria());
        } catch (NonexistentEntityException ex) {
            Logger.getLogger(MobCatTreeModel.class.getName()).log(Level.SEVERE, null, ex);
        } catch (Exception ex) {
            Logger.getLogger(MobCatTreeModel.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    public void deletarCategoria(CategoriaNode catNode) {

        catController.destroyRecursive(catNode.getCategoria().getCategoriaId());
        super.removeNodeFromParent(catNode);

    }

    public void loadSubCat(CategoriaNode node) {

        List<Categoria> catsRaiz = new CategoriaJpaController().findCategoriaEntities();
        for (Iterator<Categoria> it = catsRaiz.iterator(); it.hasNext();) {
            Categoria categoria = it.next();
            List<Categoria> cats = categoria.getCategoriaCollection();
            for (Iterator<Categoria> itCatFilha = cats.iterator(); itCatFilha.hasNext();) {
                Categoria catFilha = itCatFilha.next();
                if (catFilha.getCategoriaPai().getCategoriaId().intValue() == node.getCategoria().getCategoriaId().intValue()) {
                    if (catFilha.getRegistroCollection().size() > 0) {
                        CategoriaNode myCat = new CategoriaNode(catFilha);
                        node.add(myCat);
                    /* List<Registro> regsList = catFilha.getRegistroCollection();
                    for (Iterator<Registro> itReg = regsList.iterator(); itReg.hasNext();) {
                    Registro registro = itReg.next();
                    myCat.add(new RegistroNode(registro, catFilha));
                    }*/
                    } else {
                        CategoriaNode cat = new CategoriaNode(catFilha);
                        loadSubCat(cat);
                        node.add(cat);
                    }
                }
            }
        }
    }

    public void treeTreeExpanded(javax.swing.event.TreeExpansionEvent evt) {

        Object tr = evt.getPath().getLastPathComponent();
        if (tr instanceof CategoriaNode) {
            CategoriaNode catnode = (CategoriaNode) tr;
            catnode = new CategoriaNode(new CategoriaJpaController().findCategoria(catnode.getCategoria().getCategoriaId()));
            if (catnode.getCategoria().getCategoriaPai() != null) {
                super.insertNodeInto(catnode, new CategoriaNode(catnode.getCategoria().getCategoriaPai()), 0);
            }
        }

        System.out.println(tr);
    }
}
